#ifndef CHAT_SERVICE_H
#define CHAT_SERVICE_H

#include "network/epoll_server.h"
#include "database/mysql_pool.h"
#include "cache/redis_client.h"
#include "messaging/kafka_producer.h"
#include "messaging/kafka_consumer.h"
#include <string>
#include <memory>
#include <unordered_map>
#include <nlohmann/json.hpp>
#include <mutex>

namespace service {
namespace chat {

// 消息结构
struct ChatMessage {
    int id;
    int senderId;
    int receiverId;
    std::string content;
    std::string createdAt;
    int type; // 0: 文本, 1: 图片, 2: 文件
    int status; // 0: 未读, 1: 已读
    
    // 转换为JSON对象
    nlohmann::json toJson() const;
    
    // 从JSON对象构造
    static ChatMessage fromJson(const nlohmann::json& json);
};

// 聊天室结构
struct ChatRoom {
    int id;
    std::string name;
    std::string description;
    int creatorId;
    std::string createdAt;
    int type; // 0: 公开, 1: 私有
    
    // 转换为JSON对象
    nlohmann::json toJson() const;
    
    // 从JSON对象构造
    static ChatRoom fromJson(const nlohmann::json& json);
};

// 聊天服务类
class ChatService {
public:
    // 创建聊天服务
    static std::shared_ptr<ChatService> create(
        std::shared_ptr<database::MySQLPool> dbPool,
        std::shared_ptr<cache::RedisClient> redisClient,
        std::shared_ptr<messaging::KafkaProducer> kafkaProducer = nullptr,
        std::shared_ptr<messaging::KafkaConsumer> kafkaConsumer = nullptr);
    
    // 启动服务
    bool start(int port);
    
    // 停止服务
    void stop();
    
    // 发送私聊消息
    int sendPrivateMessage(const ChatMessage& message);
    
    // 发送群聊消息
    int sendRoomMessage(int roomId, const ChatMessage& message);
    
    // 获取私聊消息历史
    std::vector<ChatMessage> getPrivateHistory(int senderId, int receiverId, int limit = 20, int offset = 0);
    
    // 获取群聊消息历史
    std::vector<ChatMessage> getRoomHistory(int roomId, int limit = 20, int offset = 0);
    
    // 创建聊天室
    int createRoom(const ChatRoom& room);
    
    // 加入聊天室
    bool joinRoom(int roomId, int userId);
    
    // 离开聊天室
    bool leaveRoom(int roomId, int userId);
    
    // 获取用户加入的聊天室
    std::vector<ChatRoom> getUserRooms(int userId);
    
    // 获取聊天室成员
    std::vector<int> getRoomMembers(int roomId);
    
    // 标记消息为已读
    bool markAsRead(int messageId);
    
    // 获取未读消息数
    int getUnreadCount(int userId);
    
private:
    ChatService(std::shared_ptr<database::MySQLPool> dbPool,
               std::shared_ptr<cache::RedisClient> redisClient,
               std::shared_ptr<messaging::KafkaProducer> kafkaProducer,
               std::shared_ptr<messaging::KafkaConsumer> kafkaConsumer);
    
    // 处理客户端连接
    void handleConnection(std::shared_ptr<network::Connection> conn);
    
    // 处理客户端消息
    void handleMessage(std::shared_ptr<network::Connection> conn, const std::string& message);
    
    // 处理客户端断开连接
    void handleClose(std::shared_ptr<network::Connection> conn);
    
    // 处理API请求
    std::string handleRequest(const std::string& path, const std::string& method, 
                             const nlohmann::json& params);
    
    // 向指定用户发送消息
    void sendToUser(int userId, const std::string& message);
    
    // 向聊天室所有成员发送消息
    void sendToRoom(int roomId, const std::string& message);
    
    // 验证token
    bool verifyToken(const std::string& token, int& userId);
    
    // 发送事件到Kafka
    void sendEvent(const std::string& eventType, const nlohmann::json& eventData);
    
    // 处理Kafka消息
    void handleKafkaMessage(const std::string& topic, const std::string& key, 
                           const std::string& value, int64_t offset);
    
    // 初始化Kafka消费者
    bool initKafkaConsumer();

private:
    std::shared_ptr<database::MySQLPool> dbPool_;
    std::shared_ptr<cache::RedisClient> redisClient_;
    std::shared_ptr<messaging::KafkaProducer> kafkaProducer_;
    std::shared_ptr<messaging::KafkaConsumer> kafkaConsumer_;
    std::unique_ptr<network::EpollServer> server_;
    bool isRunning_;
    
    // 用户ID到连接的映射
    std::unordered_map<int, std::shared_ptr<network::Connection>> userConnections_;
    std::mutex userConnectionsMutex_;
    
    // 连接到用户ID的映射
    std::unordered_map<int, int> connectionUsers_;
    std::mutex connectionUsersMutex_;
    
    // 聊天室ID到成员的映射
    std::unordered_map<int, std::vector<int>> roomMembers_;
    std::mutex roomMembersMutex_;
    
    // 连接ID到连接的映射
    std::unordered_map<int, std::shared_ptr<network::Connection>> connections_;
    std::mutex connectionsMutex_;
};

} // namespace chat
} // namespace service

#endif // CHAT_SERVICE_H 